﻿package com.amcharts.axes
{
    import com.amcharts.*;
    import com.amcharts.chartClasses.*;
    import com.amcharts.events.*;
    import com.amcharts.geom.*;
    import com.amcharts.utils.*;
    import flash.display.*;
    import flash.events.*;
    import mx.formatters.*;

    public class ValueAxis extends AxisBase
    {
        protected var _minTemp:Number;
        protected var _includeGuidesInMinMax:Boolean;
        protected var _maxTemp:Number;
        protected var _integersOnly:Boolean;
        protected var _reversed:Boolean;
        protected var _baseCoord:Number;
        protected var _synchronizeWithAxis:ValueAxis;
        protected var _useScientificNotation:Boolean;
        protected var _foundGraphs:Boolean;
        protected var _unit:String;
        protected var _recalculateToPercents:Boolean;
        protected var _initialValueWhenRecalculating:Number = 0;
        protected var _stackType:String = "none";
        protected var _includeHidden:Boolean;
        protected var _numberFormat:NumberFormatter;
        protected var _logarithmic:Boolean;
        protected var _min:Number;
        protected var _baseValue:Number = 0;
        protected var _maxDefined:Number;
        protected var _max:Number;
        protected var _usePrefixes:Boolean;
        protected var _minMaxField:String;
        protected var _step:Number;
        protected var _unitPosition:String = "right";
        protected var _grid0:Sprite;
        protected var _expandMinMax:Boolean;
        protected var _minReal:Number;
        protected var _synchronizationMultiplyer:Number;
        protected var _stepWidth:Number;
        protected var _chart:AmCoordinateChart;
        protected var _maxReal:Number;
        protected var _maxDecCount:Number;
        protected var _minDefined:Number;
        protected var _precision:Number;
        static const VERSION:String = "1.8.3.1";

        public function ValueAxis()
        {
            _orientation = "vertical";
            _position = "left";
            this.setStyle("gridCount", 8);
            return;
        }// end function

        public function set unit(param1:String) : void
        {
            _unit = param1;
            invalidateDisplayList();
            return;
        }// end function

        public function get minReal() : Number
        {
            return _minReal;
        }// end function

        override protected function updateData() : void
        {
            if (_gridCount <= 0)
            {
                _gridCount = 1;
            }
            if (_chart.chartType != "xy")
            {
                stackGraphs("smoothedLine");
                stackGraphs("line");
                stackGraphs("column");
                stackGraphs("step");
            }
            if (_recalculateToPercents)
            {
                recalculate();
            }
            if (_synchronizationMultiplyer)
            {
            }
            if (_synchronizeWithAxis)
            {
                _foundGraphs = true;
            }
            else
            {
                _foundGraphs = false;
                getMinMax();
            }
            return;
        }// end function

        protected function createValueAxis() : void
        {
            var _loc_1:Number = NaN;
            var _loc_2:Number = NaN;
            var _loc_3:Number = NaN;
            var _loc_4:uint = 0;
            var _loc_5:Boolean = false;
            var _loc_6:Boolean = false;
            var _loc_7:Number = NaN;
            var _loc_8:Number = NaN;
            var _loc_9:Number = NaN;
            var _loc_10:Number = NaN;
            var _loc_11:NumberFormatter = null;
            var _loc_12:Boolean = false;
            var _loc_13:Number = NaN;
            var _loc_14:ValueAxisEvent = null;
            var _loc_15:Number = NaN;
            var _loc_16:String = null;
            var _loc_17:Number = NaN;
            var _loc_18:Array = null;
            var _loc_19:Number = NaN;
            var _loc_20:Number = NaN;
            var _loc_21:String = null;
            var _loc_22:Object = null;
            var _loc_23:Number = NaN;
            var _loc_24:Array = null;
            var _loc_25:Array = null;
            var _loc_26:Line = null;
            var _loc_27:uint = 0;
            var _loc_28:Guide = null;
            var _loc_29:Number = NaN;
            var _loc_30:Number = NaN;
            var _loc_31:Number = NaN;
            var _loc_32:Object = null;
            var _loc_33:ExtendedSprite = null;
            var _loc_34:AxisEvent = null;
            _maxLabelWidth = 0;
            if (_logarithmic)
            {
                _loc_3 = getMin(0, (_dataProvider.length - 1));
                if (_loc_3 <= 0)
                {
                    trace("Logarithmic scale can not display data points less or equal to 0");
                    dispatchEvent(new ValueAxisEvent(ValueAxisEvent.LOGARITHMIC_AXIS_FAILED));
                    return;
                }
            }
            if (!isNaN(_min))
            {
            }
            if (!isNaN(_max))
            {
            }
            if (_foundGraphs)
            {
            }
            if (_min != Infinity)
            {
            }
            if (_max != -Infinity)
            {
                _loc_4 = getStyle("labelFrequency");
                _loc_5 = getStyle("showFirstLabel");
                _loc_6 = getStyle("showLastLabel");
                _loc_7 = 1;
                _loc_8 = 0;
                _loc_9 = Math.round((_max - _min) / _step) + 1;
                if (_logarithmic == true)
                {
                    _loc_15 = Math.log(_max) * Math.LOG10E - Math.log(_minReal) * Math.LOG10E;
                    _stepWidth = _axisWidth / _loc_15;
                    if (_loc_15 > 2)
                    {
                        _loc_9 = Math.ceil(Math.log(_max) * Math.LOG10E) + 1;
                        _loc_8 = Math.round(Math.log(_minReal) * Math.LOG10E);
                        if (_loc_9 > _gridCount)
                        {
                            _loc_7 = Math.ceil(_loc_9 / _gridCount);
                        }
                    }
                }
                else
                {
                    _stepWidth = _axisWidth / (_max - _min);
                }
                _loc_10 = 0;
                if (_step < 1)
                {
                }
                if (_step > -1)
                {
                    _loc_16 = _step.toString();
                    if (_loc_16.indexOf("e-") != -1)
                    {
                        _loc_10 = Number(_loc_16.split("-")[1]);
                    }
                    else
                    {
                        _loc_10 = _loc_16.split(".")[1].length;
                    }
                }
                if (_integersOnly)
                {
                    _loc_10 = 0;
                }
                if (_loc_10 > _maxDecCount)
                {
                    _loc_10 = _maxDecCount;
                }
                _max = Utils.roundTo(_max, _maxDecCount);
                _min = Utils.roundTo(_min, _maxDecCount);
                _loc_11 = _chart.numberFormatter;
                _numberFormat = new NumberFormatter();
                _numberFormat.precision = _loc_10;
                _numberFormat.decimalSeparatorFrom = _loc_11.decimalSeparatorFrom;
                _numberFormat.decimalSeparatorTo = _loc_11.decimalSeparatorTo;
                _numberFormat.thousandsSeparatorFrom = _loc_11.thousandsSeparatorFrom;
                _numberFormat.thousandsSeparatorTo = _loc_11.thousandsSeparatorTo;
                _numberFormat.useNegativeSign = _loc_11.useNegativeSign;
                _numberFormat.useThousandsSeparator = _loc_11.useThousandsSeparator;
                _numberFormat.rounding = NumberBaseRoundType.NEAREST;
                if (!isNaN(_precision))
                {
                }
                if (_loc_10 < _precision)
                {
                    _numberFormat.precision = _precision;
                }
                _loc_12 = false;
                _loc_2 = _loc_8;
                while (_loc_2 < _loc_9)
                {
                    
                    _loc_17 = _step * _loc_2 + _min;
                    if (String(_loc_17).indexOf("e") != -1)
                    {
                        _loc_12 = true;
                        _loc_18 = String(_loc_17).split("e");
                        _loc_19 = Number(_loc_18[1]);
                    }
                    _loc_2 = _loc_2 + _loc_7;
                }
                _loc_2 = _loc_8;
                while (_loc_2 < _loc_9)
                {
                    
                    _loc_20 = _step * _loc_2 + _min;
                    _loc_20 = Utils.roundTo(_loc_20, (_maxDecCount + 1));
                    if (_integersOnly)
                    {
                    }
                    if (int(_loc_20) != _loc_20)
                    {
                    }
                    else
                    {
                        if (_logarithmic == true)
                        {
                            if (_loc_20 == 0)
                            {
                                _loc_20 = _minReal;
                            }
                            if (_loc_15 > 2)
                            {
                                _loc_20 = Math.pow(10, _loc_2);
                            }
                        }
                        _loc_21 = formatValue(_loc_20);
                        if (int(_loc_2 / _loc_4) != _loc_2 / _loc_4)
                        {
                            _loc_21 = undefined;
                        }
                        if (_loc_2 == 0)
                        {
                        }
                        if (_loc_5)
                        {
                            if (_loc_2 == (_loc_9 - 1))
                            {
                            }
                        }
                        if (!_loc_6)
                        {
                            _loc_21 = " ";
                        }
                        _loc_1 = getCoordinate(_loc_20);
                        _loc_22 = new _axisItemRenderer(this, _loc_1, _loc_21);
                        _loc_23 = _loc_22.width + 10 + _offset;
                        if (_loc_23 > _maxLabelWidth)
                        {
                            _maxLabelWidth = _loc_23;
                        }
                        if (_grid0)
                        {
                        }
                        if (_loc_20 == _baseValue)
                        {
                        }
                        if (_axisItemRenderer == RectangularAxisItemRenderer)
                        {
                            if (_orientation == "horizontal")
                            {
                                if (_loc_1 >= visibleAxisX)
                                {
                                }
                                if (_loc_1 <= visibleAxisX + visibleAxisWidth + 1)
                                {
                                    _loc_24 = [_loc_1, _loc_1, _loc_1 + _dx];
                                    _loc_25 = [_visibleAxisY + _visibleAxisHeight, _visibleAxisY, _visibleAxisY + _dy];
                                }
                            }
                            else
                            {
                                if (_loc_1 >= visibleAxisY)
                                {
                                }
                                if (_loc_1 <= visibleAxisHeight + visibleAxisY + 1)
                                {
                                    _loc_24 = [_visibleAxisX, _visibleAxisX + _visibleAxisWidth, _visibleAxisX + _visibleAxisWidth + _dx];
                                    _loc_25 = [_loc_1, _loc_1, _loc_1 + _dy];
                                }
                            }
                            if (_loc_24)
                            {
                                _loc_26 = new Line(_loc_24, _loc_25, this.getStyle("gridColor"), this.getStyle("gridAlpha") * 2, 0, 0);
                                _grid0.addChild(_loc_26);
                            }
                        }
                    }
                    _loc_2 = _loc_2 + _loc_7;
                }
                _loc_13 = _baseValue;
                if (_min > _baseValue)
                {
                }
                if (_max > _baseValue)
                {
                    _loc_13 = _min;
                }
                if (_min < _baseValue)
                {
                }
                if (_max < _baseValue)
                {
                    _loc_13 = _max;
                }
                if (_logarithmic)
                {
                }
                if (_loc_13 < _minReal)
                {
                    _loc_13 = _minReal;
                }
                _baseCoord = getCoordinate(_loc_13);
                _loc_14 = new ValueAxisEvent(ValueAxisEvent.AXIS_CHANGED);
                if (_logarithmic)
                {
                    _loc_14.min = _minReal;
                }
                else
                {
                    _loc_14.min = _min;
                }
                _loc_14.max = _max;
                dispatchEvent(_loc_14);
                _axisCreated = true;
            }
            else if (_axisTitle)
            {
                _axisTitle.visible = false;
            }
            if (!isNaN(_min))
            {
            }
            if (!isNaN(_max))
            {
            }
            if (_guides.length > 0)
            {
                _loc_27 = _guides.length;
                _fillAlpha = 0;
                _loc_2 = 0;
                while (_loc_2 < _loc_27)
                {
                    
                    _loc_28 = _guides[_loc_2];
                    _loc_29 = NaN;
                    if (!isNaN(_loc_28.toValue))
                    {
                        _loc_29 = getCoordinate(_loc_28.toValue);
                        new _axisItemRenderer(this, _loc_29, "", true, NaN, NaN, _loc_28);
                    }
                    _loc_30 = NaN;
                    if (!isNaN(_loc_28.value))
                    {
                        _loc_30 = getCoordinate(_loc_28.value);
                        _loc_31 = (_loc_29 - _loc_30) / 2;
                        new _axisItemRenderer(this, _loc_30, _loc_28.label, true, NaN, _loc_31, _loc_28);
                    }
                    if (isNaN(_loc_29))
                    {
                        _loc_30 = _loc_30 - 2;
                        _loc_29 = _loc_30 + 2;
                    }
                    if (!isNaN(_loc_29 - _loc_30))
                    {
                        _loc_32 = new _guideFillRenderer(this, _loc_29 - _loc_30, _loc_30, _loc_28);
                        _loc_33 = _loc_32.fill;
                        _loc_33.index = _loc_2;
                        if (_loc_28.balloonText)
                        {
                            _loc_33.addEventListener(MouseEvent.ROLL_OVER, handleGuideOver);
                            _loc_33.addEventListener(MouseEvent.ROLL_OUT, handleGuideOut);
                        }
                    }
                    _loc_2 = _loc_2 + 1;
                }
            }
            if (_axisTitle)
            {
                adjustTitlePosition();
                _maxLabelWidth = _maxLabelWidth + (_axisTitle.textHeight + 10);
            }
            if (!_ignoreAxisWidth)
            {
                _loc_34 = new AxisEvent(AxisEvent.AXIS_WIDTH_CHANGED);
                _loc_34.axis = this;
                _loc_34.width = _maxLabelWidth;
                dispatchEvent(_loc_34);
            }
            return;
        }// end function

        protected function handleSynchronization(event:Event) : void
        {
            var _loc_5:Number = NaN;
            var _loc_2:* = _synchronizeWithAxis.min;
            var _loc_3:* = _synchronizeWithAxis.max;
            var _loc_4:* = _synchronizeWithAxis.step;
            if (_synchronizationMultiplyer)
            {
                _min = _loc_2 * _synchronizationMultiplyer;
                _max = _loc_3 * _synchronizationMultiplyer;
                _step = _loc_4 * _synchronizationMultiplyer;
                _loc_5 = Math.pow(10, Math.floor(Math.log(Math.abs(_step)) * Math.LOG10E));
                _maxDecCount = Math.abs(Math.log(Math.abs(_loc_5)) * Math.LOG10E);
                _maxDecCount = Math.round(_maxDecCount);
                invalidateDisplayList();
            }
            else
            {
                throw new Error("synchronization multiplyer is not set");
            }
            return;
        }// end function

        protected function getMin(param1:Number, param2:Number) : Number
        {
            var _loc_3:Number = NaN;
            var _loc_6:Object = null;
            var _loc_7:String = null;
            var _loc_8:AmGraph = null;
            var _loc_9:Object = null;
            var _loc_10:Number = NaN;
            var _loc_11:String = null;
            var _loc_4:* = _chart.id;
            var _loc_5:* = param1;
            while (_loc_5 <= param2)
            {
                
                _loc_6 = _dataProvider.getItemAt(_loc_5).charts[_loc_4].axes[this.id].graphs;
                for (_loc_7 in _loc_6)
                {
                    
                    _loc_8 = _chart.getGraphById(_loc_7);
                    if (_loc_8.includeInMinMax)
                    {
                        if (_loc_8.hidden)
                        {
                        }
                        if (_includeHidden)
                        {
                            if (isNaN(_loc_3))
                            {
                                _loc_3 = Infinity;
                            }
                            _foundGraphs = true;
                            _loc_9 = _loc_6[_loc_7].values;
                            if (_recalculateToPercents)
                            {
                                _loc_9 = _loc_6[_loc_7].percents;
                            }
                            if (_minMaxField)
                            {
                                _loc_10 = _loc_9[_minMaxField];
                                if (_loc_10 < _loc_3)
                                {
                                    _loc_3 = _loc_10;
                                }
                                continue;
                            }
                            for (_loc_11 in _loc_9)
                            {
                                
                                if (_loc_11 != "percents")
                                {
                                }
                                if (_loc_11 != "total")
                                {
                                    _loc_10 = _loc_9[_loc_11];
                                    if (_loc_10 < _loc_3)
                                    {
                                        _loc_3 = _loc_10;
                                    }
                                }
                            }
                        }
                    }
                }
                _loc_5 = _loc_5 + 1;
            }
            return _loc_3;
        }// end function

        public function get includeGuidesInMinMax() : Boolean
        {
            return _includeGuidesInMinMax;
        }// end function

        public function coordinateToValue(param1:Number) : Number
        {
            var _loc_2:Number = NaN;
            var _loc_3:Number = NaN;
            if (isNaN(param1))
            {
                return NaN;
            }
            if (_logarithmic == true)
            {
                if (_rotate)
                {
                    if (_reversed == true)
                    {
                        _loc_3 = (_axisWidth - param1) / _stepWidth;
                    }
                    else
                    {
                        _loc_3 = param1 / _stepWidth;
                    }
                }
                else if (_reversed == true)
                {
                    _loc_3 = param1 / _stepWidth;
                }
                else
                {
                    _loc_3 = (_axisWidth - param1) / _stepWidth;
                }
                _loc_2 = Math.pow(10, _loc_3 + Math.log(_minReal) * Math.LOG10E);
            }
            else if (_reversed == true)
            {
                if (_rotate)
                {
                    _loc_2 = _min - (param1 - _axisWidth) / _stepWidth;
                }
                else
                {
                    _loc_2 = param1 / _stepWidth + _min;
                }
            }
            else if (_rotate)
            {
                _loc_2 = param1 / _stepWidth + _min;
            }
            else
            {
                _loc_2 = _min - (param1 - _axisWidth) / _stepWidth;
            }
            return _loc_2;
        }// end function

        protected function generateNumber(param1:Number, param2:Number) : Number
        {
            var _loc_4:Number = NaN;
            var _loc_3:String = "";
            if (param2 < 1)
            {
                _loc_4 = Math.abs(param2) - 1;
            }
            else
            {
                _loc_4 = Math.abs(param2);
            }
            var _loc_5:Number = 0;
            while (_loc_5 < _loc_4)
            {
                
                _loc_3 = _loc_3 + "0";
                _loc_5 = _loc_5 + 1;
            }
            if (param2 < 1)
            {
                return Number("0." + _loc_3 + String(param1));
            }
            return Number(String(param1) + _loc_3);
        }// end function

        public function get baseValue() : Number
        {
            return _baseValue;
        }// end function

        public function dispatchZoomEvent(param1:Number, param2:Number) : void
        {
            var _loc_3:* = new ValueAxisEvent(ValueAxisEvent.AXIS_ZOOMED);
            _loc_3.startValue = param1;
            _loc_3.endValue = param2;
            dispatchEvent(_loc_3);
            return;
        }// end function

        protected function getMax() : Number
        {
            var _loc_1:Number = NaN;
            var _loc_4:Object = null;
            var _loc_5:String = null;
            var _loc_6:AmGraph = null;
            var _loc_7:Object = null;
            var _loc_8:Number = NaN;
            var _loc_9:String = null;
            var _loc_2:* = _chart.id;
            var _loc_3:* = _start;
            while (_loc_3 <= _end)
            {
                
                _loc_4 = _dataProvider.getItemAt(_loc_3).charts[_loc_2].axes[this.id].graphs;
                for (_loc_5 in _loc_4)
                {
                    
                    _loc_6 = _chart.getGraphById(_loc_5);
                    if (_loc_6.includeInMinMax)
                    {
                        if (_loc_6.hidden)
                        {
                        }
                        if (_includeHidden)
                        {
                            if (isNaN(_loc_1))
                            {
                                _loc_1 = -Infinity;
                            }
                            _foundGraphs = true;
                            _loc_7 = _loc_4[_loc_5].values;
                            if (_recalculateToPercents)
                            {
                                _loc_7 = _loc_4[_loc_5].percents;
                            }
                            if (_minMaxField)
                            {
                                _loc_8 = _loc_7[_minMaxField];
                                if (_loc_8 > _loc_1)
                                {
                                    _loc_1 = _loc_8;
                                }
                                continue;
                            }
                            for (_loc_9 in _loc_7)
                            {
                                
                                if (_loc_9 != "percents")
                                {
                                }
                                if (_loc_9 != "total")
                                {
                                    _loc_8 = _loc_7[_loc_9];
                                    if (_loc_8 > _loc_1)
                                    {
                                        _loc_1 = _loc_8;
                                    }
                                }
                            }
                        }
                    }
                }
                _loc_3 = _loc_3 + 1;
            }
            return _loc_1;
        }// end function

        public function get useScientificNotation() : Boolean
        {
            return _useScientificNotation;
        }// end function

        public function set includeGuidesInMinMax(param1:Boolean) : void
        {
            _includeGuidesInMinMax = param1;
            _dataChanged = true;
            invalidateChart();
            return;
        }// end function

        public function get logarithmic() : Boolean
        {
            return _logarithmic;
        }// end function

        public function get integersOnly() : Boolean
        {
            return _integersOnly;
        }// end function

        public function set baseValue(param1:Number) : void
        {
            _baseValue = param1;
            return;
        }// end function

        public function set grid0(param1:Sprite) : void
        {
            _grid0 = param1;
            return;
        }// end function

        public function get min() : Number
        {
            return _min;
        }// end function

        public function get recalculateToPercents() : Boolean
        {
            return _recalculateToPercents;
        }// end function

        public function get synchronizationMultiplyer() : Number
        {
            return _synchronizationMultiplyer;
        }// end function

        public function get usePrefixes() : Boolean
        {
            return _usePrefixes;
        }// end function

        public function get initialValueWhenRecalculating() : Number
        {
            return _initialValueWhenRecalculating;
        }// end function

        public function get max() : Number
        {
            return _max;
        }// end function

        public function getCoordinate(param1:Number) : Number
        {
            var _loc_2:Number = NaN;
            var _loc_3:Number = NaN;
            if (isNaN(param1))
            {
                return NaN;
            }
            if (_logarithmic == true)
            {
                _loc_3 = Math.log(param1) * Math.LOG10E - Math.log(_minReal) * Math.LOG10E;
                if (_rotate)
                {
                    if (_reversed == true)
                    {
                        _loc_2 = _axisWidth - _stepWidth * _loc_3;
                    }
                    else
                    {
                        _loc_2 = _stepWidth * _loc_3;
                    }
                }
                else if (_reversed == true)
                {
                    _loc_2 = _stepWidth * _loc_3;
                }
                else
                {
                    _loc_2 = _axisWidth - _stepWidth * _loc_3;
                }
            }
            else if (_reversed == true)
            {
                if (_rotate)
                {
                    _loc_2 = _axisWidth - _stepWidth * (param1 - _min);
                }
                else
                {
                    _loc_2 = _stepWidth * (param1 - _min);
                }
            }
            else if (_rotate)
            {
                _loc_2 = _stepWidth * (param1 - _min);
            }
            else
            {
                _loc_2 = _axisWidth - _stepWidth * (param1 - _min);
            }
            _loc_2 = Math.round(_loc_2 * 10) / 10;
            return _loc_2;
        }// end function

        public function zoomToValues(param1:Number, param2:Number) : void
        {
            var _loc_4:Number = NaN;
            if (param2 < param1)
            {
                _loc_4 = param2;
                param2 = param1;
                param1 = _loc_4;
            }
            if (param1 < _min)
            {
                param1 = _min;
            }
            if (param2 > _max)
            {
                param2 = _max;
            }
            var _loc_3:* = new ValueAxisEvent(ValueAxisEvent.AXIS_SELF_ZOOMED);
            _loc_3.multiplyer = _axisWidth / Math.abs(getCoordinate(param2) - getCoordinate(param1));
            if (_orientation == "vertical")
            {
                if (_reversed)
                {
                    _loc_3.position = getCoordinate(param1);
                }
                else
                {
                    _loc_3.position = getCoordinate(param2);
                }
            }
            else if (_reversed)
            {
                _loc_3.position = getCoordinate(param2);
            }
            else
            {
                _loc_3.position = getCoordinate(param1);
            }
            dispatchEvent(_loc_3);
            return;
        }// end function

        protected function invalidateChart() : void
        {
            if (!_scrollbar)
            {
            }
            if (_chart)
            {
                _chart.dataChanged = true;
                _chart.invalidateProperties();
            }
            else
            {
                _dataChanged = true;
                invalidateDisplayList();
            }
            return;
        }// end function

        public function set useScientificNotation(param1:Boolean) : void
        {
            _useScientificNotation = param1;
            invalidateDisplayList();
            return;
        }// end function

        public function set logarithmic(param1:Boolean) : void
        {
            _logarithmic = param1;
            invalidateChart();
            return;
        }// end function

        public function set integersOnly(param1:Boolean) : void
        {
            _integersOnly = param1;
            invalidateDisplayList();
            return;
        }// end function

        public function set reversed(param1:Boolean) : void
        {
            _reversed = param1;
            invalidateChart();
            return;
        }// end function

        public function get precision() : Number
        {
            return _precision;
        }// end function

        public function get unit() : String
        {
            return _unit;
        }// end function

        public function set minTemp(param1:Number) : void
        {
            _minTemp = param1;
            _dataChanged = true;
            invalidateDisplayList();
            return;
        }// end function

        protected function stackGraphs(param1:String) : void
        {
            var _loc_6:Number = NaN;
            var _loc_9:AmGraph = null;
            var _loc_10:String = null;
            var _loc_11:AmGraph = null;
            var _loc_12:GraphDataItem = null;
            var _loc_13:Number = NaN;
            var _loc_14:Number = NaN;
            var _loc_16:Array = null;
            var _loc_17:Number = NaN;
            var _loc_18:Number = NaN;
            var _loc_2:* = new Array();
            var _loc_3:* = new Array();
            var _loc_4:* = new Array();
            var _loc_5:* = new Array();
            var _loc_7:* = _chart.id;
            var _loc_8:* = _chart.graphs;
            if (param1 != "line")
            {
            }
            if (param1 != "step")
            {
            }
            if (param1 == "smoothedLine")
            {
                if (_stackType != "regular")
                {
                }
            }
            if (_stackType == "100%")
            {
                _loc_13 = 0;
                while (_loc_13 < _loc_8.length)
                {
                    
                    _loc_11 = _loc_8[_loc_13];
                    if (!_loc_11.hidden)
                    {
                        _loc_10 = _loc_11.type;
                        if (_loc_11.chart == _chart)
                        {
                        }
                        if (_loc_11.valueAxis == this)
                        {
                        }
                        if (param1 == _loc_10)
                        {
                        }
                        if (_loc_11.stackable)
                        {
                            if (_loc_9)
                            {
                                _loc_11.stackGraph = _loc_9;
                                _loc_9 = _loc_11;
                            }
                            else
                            {
                                _loc_9 = _loc_11;
                            }
                        }
                    }
                    _loc_13 = _loc_13 + 1;
                }
            }
            var _loc_15:* = new NumberFormatter();
            _loc_15.rounding = NumberBaseRoundType.NEAREST;
            _loc_14 = _start;
            while (_loc_14 <= _end)
            {
                
                _loc_13 = 0;
                while (_loc_13 < _loc_8.length)
                {
                    
                    _loc_11 = _loc_8[_loc_13];
                    if (!_loc_11.hidden)
                    {
                        _loc_10 = _loc_11.type;
                        if (_loc_11.chart == _chart)
                        {
                        }
                        if (_loc_11.valueAxis == this)
                        {
                        }
                        if (param1 == _loc_10)
                        {
                        }
                        if (_loc_11.stackable)
                        {
                            _loc_12 = _dataProvider.getItemAt(_loc_14).charts[_loc_7].axes[this.id].graphs[_loc_11.id];
                            _loc_6 = _loc_12.values.value;
                            if (!isNaN(_loc_6))
                            {
                                if (isNaN(_loc_5[_loc_14]))
                                {
                                    _loc_5[_loc_14] = Math.abs(_loc_6);
                                }
                                else
                                {
                                    _loc_5[_loc_14] = _loc_5[_loc_14] + Math.abs(_loc_6);
                                }
                                _loc_16 = String(_loc_6).split(".");
                                if (_loc_16.length == 2)
                                {
                                    _loc_17 = _loc_16[1].length;
                                }
                                if (_loc_15.precision < _loc_17)
                                {
                                    _loc_15.precision = _loc_17;
                                }
                                if (_stackType == "regular")
                                {
                                    if (param1 != "line")
                                    {
                                    }
                                    if (param1 != "step")
                                    {
                                    }
                                    if (param1 == "smoothedLine")
                                    {
                                        if (isNaN(_loc_2[_loc_14]))
                                        {
                                            _loc_2[_loc_14] = _loc_6;
                                            _loc_12.values.close = _loc_6;
                                        }
                                        else
                                        {
                                            if (isNaN(_loc_6))
                                            {
                                                _loc_12.values.close = _loc_2[_loc_14];
                                            }
                                            else
                                            {
                                                _loc_12.values.close = _loc_6 + _loc_2[_loc_14];
                                            }
                                            _loc_2[_loc_14] = _loc_12.values.close;
                                        }
                                    }
                                    if (param1 == "column")
                                    {
                                        if (!isNaN(_loc_6))
                                        {
                                            _loc_12.values.close = _loc_6;
                                            if (_loc_6 < 0)
                                            {
                                                _loc_12.values.close = _loc_6;
                                                if (!isNaN(_loc_3[_loc_14]))
                                                {
                                                    _loc_12.values.close = _loc_12.values.close + _loc_3[_loc_14];
                                                    _loc_12.values.open = _loc_3[_loc_14];
                                                }
                                                _loc_3[_loc_14] = _loc_12.values.close;
                                            }
                                            else
                                            {
                                                _loc_12.values.close = _loc_6;
                                                if (!isNaN(_loc_4[_loc_14]))
                                                {
                                                    _loc_12.values.close = _loc_12.values.close + _loc_4[_loc_14];
                                                    _loc_12.values.open = _loc_4[_loc_14];
                                                }
                                                _loc_4[_loc_14] = _loc_12.values.close;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    _loc_13 = _loc_13 + 1;
                }
                _loc_14 = _loc_14 + 1;
            }
            _loc_14 = _start;
            while (_loc_14 <= _end)
            {
                
                _loc_13 = 0;
                while (_loc_13 < _loc_8.length)
                {
                    
                    _loc_11 = _loc_8[_loc_13];
                    if (!_loc_11.hidden)
                    {
                        _loc_10 = _loc_11.type;
                        if (_loc_11.chart == _chart)
                        {
                        }
                        if (_loc_11.valueAxis == this)
                        {
                        }
                        if (param1 == _loc_10)
                        {
                        }
                        if (_loc_11.stackable)
                        {
                            _loc_12 = _dataProvider.getItemAt(_loc_14).charts[_loc_7].axes[this.id].graphs[_loc_11.id];
                            _loc_6 = _loc_12.values.value;
                            if (!isNaN(_loc_6))
                            {
                                _loc_18 = _loc_6 / _loc_5[_loc_14] * 100;
                                _loc_12.values.percents = _loc_18;
                                _loc_12.values.total = _loc_5[_loc_14];
                                if (_stackType == "100%")
                                {
                                    if (isNaN(_loc_3[_loc_14]))
                                    {
                                        _loc_3[_loc_14] = 0;
                                    }
                                    if (isNaN(_loc_4[_loc_14]))
                                    {
                                        _loc_4[_loc_14] = 0;
                                    }
                                    if (_loc_18 < 0)
                                    {
                                        _loc_12.values.close = _loc_18 + _loc_3[_loc_14];
                                        _loc_12.values.open = _loc_3[_loc_14];
                                        _loc_3[_loc_14] = _loc_12.values.close;
                                    }
                                    else
                                    {
                                        _loc_12.values.close = _loc_18 + _loc_4[_loc_14];
                                        _loc_12.values.open = _loc_4[_loc_14];
                                        _loc_4[_loc_14] = _loc_12.values.close;
                                    }
                                }
                            }
                        }
                    }
                    _loc_13 = _loc_13 + 1;
                }
                _loc_14 = _loc_14 + 1;
            }
            return;
        }// end function

        protected function recalculate() : void
        {
            var _loc_3:AmGraph = null;
            var _loc_4:Number = NaN;
            var _loc_5:String = null;
            var _loc_6:GraphDataItem = null;
            var _loc_7:Number = NaN;
            var _loc_8:Number = NaN;
            var _loc_9:Number = NaN;
            var _loc_10:Number = NaN;
            var _loc_11:Object = null;
            var _loc_12:String = null;
            var _loc_13:Number = NaN;
            var _loc_14:Number = NaN;
            var _loc_1:* = _chart.graphs.length;
            var _loc_2:Number = 0;
            while (_loc_2 < _loc_1)
            {
                
                _loc_3 = _chart.graphs[_loc_2];
                _loc_4 = NaN;
                if (_loc_3.valueAxis == this)
                {
                    _loc_5 = "value";
                    if (_loc_3.type != "candlestick")
                    {
                    }
                    if (_loc_3.type == "ohlc")
                    {
                        _loc_5 = "open";
                    }
                    _loc_7 = Utils.fitToBounds((_end + 1), 0, (_dataProvider.length - 1));
                    _loc_8 = _start;
                    if (_loc_8 > 0)
                    {
                        _loc_8 = _loc_8 - 1;
                    }
                    _loc_9 = _start;
                    while (_loc_9 <= _loc_7)
                    {
                        
                        _loc_6 = _dataProvider.getItemAt(_loc_9).charts[_chart.id].axes[this.id].graphs[_loc_3.id];
                        _loc_4 = _loc_6.values[_loc_5];
                        if (!isNaN(_loc_4))
                        {
                            break;
                        }
                        _loc_9 = _loc_9 + 1;
                    }
                    _loc_10 = _loc_8;
                    while (_loc_10 <= _loc_7)
                    {
                        
                        _loc_6 = _dataProvider.getItemAt(_loc_10).charts[_chart.id].axes[this.id].graphs[_loc_3.id];
                        _loc_11 = _loc_6.values;
                        for (_loc_12 in _loc_11)
                        {
                            
                            if (_loc_12 != "percents")
                            {
                                _loc_13 = _loc_11[_loc_12];
                                _loc_14 = _loc_13 / _loc_4 * 100 - 100 + _initialValueWhenRecalculating;
                                _loc_6.setPercent(_loc_12, _loc_14);
                                continue;
                            }
                            _loc_6.setPercent(_loc_12, _loc_11[_loc_12]);
                        }
                        _loc_10 = _loc_10 + 1;
                    }
                }
                _loc_2 = _loc_2 + 1;
            }
            return;
        }// end function

        protected function getMinMax() : void
        {
            var _loc_9:Number = NaN;
            var _loc_17:String = null;
            var _loc_18:uint = 0;
            var _loc_19:Guide = null;
            var _loc_20:Number = NaN;
            var _loc_21:Number = NaN;
            var _loc_22:Number = NaN;
            var _loc_1:Boolean = false;
            var _loc_2:Number = 0;
            while (_loc_2 < _chart.graphs.length)
            {
                
                _loc_17 = _chart.graphs[_loc_2].type;
                if (_loc_17 != "line")
                {
                }
                if (_loc_17 != "step")
                {
                }
                if (_loc_17 == "smoothedLine")
                {
                    if (_expandMinMax)
                    {
                        _loc_1 = true;
                    }
                }
                _loc_2 = _loc_2 + 1;
            }
            var _loc_3:* = _start;
            var _loc_4:* = _end;
            if (_loc_1)
            {
                if (_loc_3 > 0)
                {
                    _loc_3 = _loc_3 - 1;
                }
                if (_loc_4 < (_dataProvider.length - 1))
                {
                    _loc_4 = _loc_4 + 1;
                }
            }
            if (_chart is AmSerialChart)
            {
                if (AmSerialChart(_chart).categoryAxis.parseDates == true)
                {
                }
                if (!_loc_1)
                {
                    if (_loc_4 < (_dataProvider.length - 1))
                    {
                        _loc_4 = _loc_4 + 1;
                    }
                }
            }
            _min = getMin(_loc_3, _loc_4);
            _max = getMax();
            var _loc_5:* = _guides.length;
            if (_includeGuidesInMinMax)
            {
            }
            if (_loc_5 > 0)
            {
                _loc_18 = 0;
                while (_loc_18 < _loc_5)
                {
                    
                    _loc_19 = _guides[_loc_18];
                    if (_loc_19.toValue < _min)
                    {
                        _min = _loc_19.toValue;
                    }
                    if (_loc_19.value < _min)
                    {
                        _min = _loc_19.value;
                    }
                    if (_loc_19.toValue > _max)
                    {
                        _max = _loc_19.toValue;
                    }
                    if (_loc_19.value > _max)
                    {
                        _max = _loc_19.value;
                    }
                    _loc_18 = _loc_18 + 1;
                }
            }
            if (!isNaN(_minDefined))
            {
                _min = _minDefined;
            }
            if (!isNaN(_maxDefined))
            {
                _max = _maxDefined;
            }
            if (_min > _max)
            {
                _loc_20 = _max;
                _max = _min;
                _min = _loc_20;
            }
            if (!isNaN(_minTemp))
            {
                _min = _minTemp;
            }
            if (!isNaN(_maxTemp))
            {
                _max = _maxTemp;
            }
            _minReal = _min;
            _maxReal = _max;
            if (_min == 0)
            {
            }
            if (_max == 0)
            {
                _max = 9;
            }
            if (_min > _max)
            {
                _min = _max - 1;
            }
            var _loc_6:* = _min;
            var _loc_7:* = _max;
            var _loc_8:* = _max - _min;
            if (_loc_8 == 0)
            {
                _loc_9 = Math.pow(10, Math.floor(Math.log(Math.abs(_max)) * Math.LOG10E)) / 10;
            }
            else
            {
                _loc_9 = Math.pow(10, Math.floor(Math.log(Math.abs(_loc_8)) * Math.LOG10E)) / 10;
            }
            if (isNaN(_maxDefined))
            {
                isNaN(_maxDefined);
            }
            if (isNaN(_maxTemp))
            {
                _max = Math.ceil(_max / _loc_9) * _loc_9 + _loc_9;
            }
            if (isNaN(_minDefined))
            {
                isNaN(_minDefined);
            }
            if (isNaN(_minTemp))
            {
                _min = Math.floor(_min / _loc_9) * _loc_9 - _loc_9;
            }
            if (_min < 0)
            {
            }
            if (_loc_6 >= 0)
            {
                _min = 0;
            }
            if (_max > 0)
            {
            }
            if (_loc_7 <= 0)
            {
                _max = 0;
            }
            if (_stackType == "100%")
            {
                if (_min < 0)
                {
                    _min = -100;
                }
                else
                {
                    _min = 0;
                }
                if (_max < 0)
                {
                    _max = 0;
                }
                else
                {
                    _max = 100;
                }
            }
            _loc_8 = _max - _min;
            _loc_9 = Math.pow(10, Math.floor(Math.log(Math.abs(_loc_8)) * Math.LOG10E)) / 10;
            _step = Math.ceil(_loc_8 / _gridCount / _loc_9) * _loc_9;
            var _loc_10:* = Math.pow(10, Math.floor(Math.log(Math.abs(_step)) * Math.LOG10E));
            var _loc_11:* = _loc_10.toExponential(0);
            var _loc_12:* = _loc_11.split("e");
            var _loc_13:* = _loc_12[0];
            var _loc_14:* = _loc_12[1];
            if (_loc_13 == 9)
            {
                _loc_14 = _loc_14 + 1;
            }
            _loc_10 = generateNumber(1, _loc_14);
            var _loc_15:* = Math.ceil(_step / _loc_10);
            if (_loc_15 > 5)
            {
                _loc_15 = 10;
            }
            if (_loc_15 <= 5)
            {
            }
            if (_loc_15 > 2)
            {
                _loc_15 = 5;
            }
            _step = Math.ceil(_step / (_loc_10 * _loc_15)) * _loc_10 * _loc_15;
            if (_loc_10 < 1)
            {
                _maxDecCount = Math.abs(Math.log(Math.abs(_loc_10)) * Math.LOG10E);
                _maxDecCount = Math.round(_maxDecCount);
                _step = Utils.roundTo(_step, (_maxDecCount + 1));
            }
            else
            {
                _maxDecCount = 0;
            }
            _min = _step * Math.floor(_min / _step);
            _max = _step * Math.ceil(_max / _step);
            if (_min < 0)
            {
            }
            if (_loc_6 >= 0)
            {
                _min = 0;
            }
            if (_max > 0)
            {
            }
            if (_loc_7 <= 0)
            {
                _max = 0;
            }
            if (_minReal > 1)
            {
            }
            if (_max - _minReal > 1)
            {
                _minReal = Math.floor(_minReal);
            }
            _loc_8 = Math.pow(10, Math.floor(Math.log(Math.abs(_minReal)) * Math.LOG10E));
            if (_min == 0)
            {
                _minReal = _loc_8;
            }
            if (_min == 0)
            {
            }
            if (_minReal > 1)
            {
                _minReal = 1;
            }
            if (_min > 0)
            {
            }
            if (_minReal - _step > 0)
            {
                if (_min + _step < _minReal)
                {
                    _minReal = _min + _step;
                }
                else
                {
                    _minReal = _min;
                }
            }
            var _loc_16:* = Math.log(_loc_7) * Math.LOG10E - Math.log(_loc_6) * Math.LOG10E;
            if (_logarithmic)
            {
                if (_loc_16 > 2)
                {
                    _min = Math.pow(10, Math.floor(Math.log(Math.abs(_loc_6)) * Math.LOG10E));
                    _minReal = _min;
                    _max = Math.pow(10, Math.ceil(Math.log(Math.abs(_loc_7)) * Math.LOG10E));
                }
                else
                {
                    _loc_21 = Math.pow(10, Math.floor(Math.log(Math.abs(_min)) * Math.LOG10E)) / 10;
                    _loc_22 = Math.pow(10, Math.floor(Math.log(Math.abs(_loc_6)) * Math.LOG10E)) / 10;
                    if (_loc_21 < _loc_22)
                    {
                        _min = 10 * _loc_22;
                        _minReal = _min;
                    }
                }
            }
            return;
        }// end function

        public function set maxTemp(param1:Number) : void
        {
            _maxTemp = param1;
            _dataChanged = true;
            invalidateDisplayList();
            return;
        }// end function

        public function set synchronizationMultiplyer(param1:Number) : void
        {
            _synchronizationMultiplyer = param1;
            invalidateChart();
            return;
        }// end function

        protected function handleGuideOver(event:MouseEvent) : void
        {
            var _loc_2:* = event.target.index;
            var _loc_3:* = _guides[_loc_2];
            _chart.balloon.follow = true;
            _chart.balloon.changeColor(_loc_3.balloonColor);
            _chart.balloon.show(_loc_3.balloonText);
            return;
        }// end function

        public function set recalculateToPercents(param1:Boolean) : void
        {
            _recalculateToPercents = param1;
            invalidateChart();
            return;
        }// end function

        public function get baseCoord() : Number
        {
            return _baseCoord;
        }// end function

        public function set rotate(param1:Boolean) : void
        {
            if (param1 == true)
            {
                _orientation = "horizontal";
            }
            else
            {
                _orientation = "vertical";
            }
            fixPosition();
            _rotate = param1;
            return;
        }// end function

        public function formatValue(param1:Number) : String
        {
            var _loc_2:String = null;
            var _loc_3:Boolean = false;
            var _loc_4:Array = null;
            var _loc_5:Array = null;
            var _loc_6:Number = NaN;
            var _loc_7:Number = NaN;
            if (_logarithmic == true)
            {
                if (String(param1).indexOf("e") != -1)
                {
                    _loc_3 = true;
                }
                else
                {
                    _loc_3 = false;
                }
            }
            if (_useScientificNotation)
            {
                _loc_3 = true;
            }
            if (_usePrefixes)
            {
                _loc_3 = false;
            }
            if (!_loc_3)
            {
                if (_logarithmic)
                {
                    _loc_4 = String(param1).split(".");
                    if (_loc_4[1])
                    {
                        _numberFormat.precision = _loc_4[1].length;
                        _numberFormat.rounding = NumberBaseRoundType.NONE;
                    }
                    else
                    {
                        _numberFormat.precision = -1;
                        _numberFormat.rounding = NumberBaseRoundType.NEAREST;
                    }
                }
                if (_usePrefixes)
                {
                    _loc_2 = Utils.addPrefix(param1, _chart.prefixesOfBigNumbers, _chart.prefixesOfSmallNumbers, _numberFormat);
                }
                else
                {
                    _loc_2 = _numberFormat.format(param1);
                }
            }
            else
            {
                if (String(param1).indexOf("e") == -1)
                {
                    _loc_2 = param1.toExponential(15);
                }
                else
                {
                    _loc_2 = String(param1);
                }
                _loc_5 = _loc_2.split("e");
                _loc_6 = Number(_loc_5[0]);
                _loc_7 = Number(_loc_5[1]);
                if (_loc_6 == 10)
                {
                    _loc_6 = 1;
                    _loc_7 = _loc_7 + 1;
                }
                _loc_2 = _loc_6 + "e" + _loc_7;
                if (param1 == 0)
                {
                    _loc_2 = "0";
                }
                if (param1 == 1)
                {
                    _loc_2 = "1";
                }
            }
            if (_recalculateToPercents)
            {
                _loc_2 = _loc_2 + "%";
            }
            else if (_unit)
            {
                if (_unitPosition == "left")
                {
                    _loc_2 = _unit + _loc_2;
                }
                else
                {
                    _loc_2 = _loc_2 + _unit;
                }
            }
            return _loc_2;
        }// end function

        public function get reversed() : Boolean
        {
            return _reversed;
        }// end function

        public function set chart(param1:AmCoordinateChart) : void
        {
            _chart = param1;
            return;
        }// end function

        public function set stackType(param1:String) : void
        {
            _stackType = param1;
            invalidateChart();
            return;
        }// end function

        public function set unitPosition(param1:String) : void
        {
            _unitPosition = param1;
            invalidateDisplayList();
            return;
        }// end function

        public function set max(param1:Number) : void
        {
            _maxDefined = param1;
            invalidateChart();
            return;
        }// end function

        public function get step() : Number
        {
            return _step;
        }// end function

        public function set usePrefixes(param1:Boolean) : void
        {
            _usePrefixes = param1;
            invalidateDisplayList();
            return;
        }// end function

        public function set minMaxField(param1:String) : void
        {
            _minMaxField = param1;
            return;
        }// end function

        public function set expandMinMax(param1:Boolean) : void
        {
            _expandMinMax = param1;
            return;
        }// end function

        public function set initialValueWhenRecalculating(param1:Number) : void
        {
            _initialValueWhenRecalculating = param1;
            return;
        }// end function

        public function get unitPosition() : String
        {
            return _unitPosition;
        }// end function

        public function set min(param1:Number) : void
        {
            _minDefined = param1;
            invalidateChart();
            return;
        }// end function

        public function get chart() : AmCoordinateChart
        {
            return _chart;
        }// end function

        public function get stackType() : String
        {
            return _stackType;
        }// end function

        public function set includeHidden(param1:Boolean) : void
        {
            _includeHidden = param1;
            invalidateChart();
            return;
        }// end function

        public function set synchronizeWithAxis(param1:ValueAxis) : void
        {
            _synchronizeWithAxis = param1;
            _synchronizeWithAxis.removeEventListener(ValueAxisEvent.AXIS_CHANGED, handleSynchronization);
            _synchronizeWithAxis.addEventListener(ValueAxisEvent.AXIS_CHANGED, handleSynchronization);
            invalidateChart();
            return;
        }// end function

        override protected function updateDisplayList(param1:Number, param2:Number) : void
        {
            super.updateDisplayList(param1, param2);
            if (_chart)
            {
                if (_dataProvider.length > 0)
                {
                    if (_dataChanged == true)
                    {
                        updateData();
                        _dataChanged = false;
                    }
                    createValueAxis();
                }
            }
            return;
        }// end function

        protected function handleGuideOut(event:MouseEvent) : void
        {
            _chart.balloon.hide();
            return;
        }// end function

        public function set precision(param1:Number) : void
        {
            _precision = param1;
            invalidateDisplayList();
            return;
        }// end function

    }
}
